package com.code.thread.abc;

import java.util.concurrent.Semaphore;

/**
 * Semaphore是一个计数信号量，用来管理一定数量的许可证。
 * 每个线程在访问共享资源之前，需要先获取一个许可证，如果许可证已经被其他线程占用，则需要等待，直到许可证可用。
 * 当线程使用完共享资源后，需要释放许可证，使其他线程可以继续访问。
 */
public class AbcSemaphore {
    private static Semaphore a = new Semaphore(1);
    private static Semaphore b = new Semaphore(0);
    private static Semaphore c = new Semaphore(0);

    static class ThreadA extends Thread {
        public void run() {
            while (true) {
                try {
                    a.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("A");
                b.release();
            }
        }
    }

    static class ThreadB extends Thread {
        public void run() {
            while (true) {
                try {
                    b.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("B");
                c.release();
            }
        }
    }

    static class ThreadC extends Thread {
        public void run() {
            while (true) {
                try {
                    c.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("C");
                a.release();
            }
        }
    }
    public static void main(String[] args) {
        new AbcSemaphore.ThreadA().start();
        new AbcSemaphore.ThreadB().start();
        new AbcSemaphore.ThreadC().start();
    }

}
